import { defineStore } from 'pinia'
import { listStorageConfig } from '@/api/filemanager/storage'

/**
 * 文件存储配置缓存管理
 * 用于缓存存储配置列表，避免重复请求API
 */
const useFileConfigStore = defineStore('fileConfig', {
  state: () => ({
    // 存储配置列表
    configs: [],
    // 缓存时间戳
    cacheTime: null,
    // 缓存有效期（毫秒）- 默认30分钟
    cacheExpiry: 30 * 60 * 1000,
    // 是否正在加载
    loading: false,
    // 是否已初始化
    initialized: false
  }),

  getters: {
    /**
     * 获取启用的存储配置列表
     */
    enabledConfigs: (state) => {
      return state.configs.filter(config => config.status === 1)
    },

    /**
     * 获取默认存储配置
     */
    defaultConfig: (state) => {
      return state.configs.find(config => config.isDefault === 1 && config.status === 1)
    },

    /**
     * 检查缓存是否有效
     */
    isCacheValid: (state) => {
      if (!state.cacheTime) return false
      return (Date.now() - state.cacheTime) < state.cacheExpiry
    },

    /**
     * 检查是否需要刷新缓存
     */
    needsRefresh: (state) => {
      return !state.initialized || !state.isCacheValid || state.configs.length === 0
    }
  },

  actions: {
    /**
     * 获取存储配置列表（智能缓存）
     * @param {Object} options - 选项
     * @param {boolean} options.forceRefresh - 是否强制刷新缓存
     * @param {boolean} options.enabledOnly - 是否只返回启用的配置
     * @returns {Promise<Array>} 存储配置列表
     */
    async getConfigs(options = {}) {
      const { forceRefresh = false, enabledOnly = true } = options

      // 如果强制刷新，直接重新加载
      if (forceRefresh) {
        await this.loadConfigs()
        return enabledOnly ? this.enabledConfigs : this.configs
      }

      // 如果缓存有效，直接返回缓存数据
      if (!this.needsRefresh) {
        return enabledOnly ? this.enabledConfigs : this.configs
      }

      // 避免重复加载 - 如果正在加载，返回当前缓存
      if (this.loading) {
        return enabledOnly ? this.enabledConfigs : this.configs
      }
      try {
        await this.loadConfigs()
      } catch (error) {
        console.error('❌ 加载文件存储配置失败:', error)
        // 即使加载失败，也返回当前缓存的数据
      }
      return enabledOnly ? this.enabledConfigs : this.configs
    },

    /**
     * 加载存储配置列表
     */
    async loadConfigs() {
      if (this.loading) return

      this.loading = true
      try {
        const response = await listStorageConfig({
          pageNum: 1,
          pageSize: 100,
          status: undefined // 获取所有状态的配置
        })

        if (response.code === 200) {
          this.configs = response.rows || []
          this.cacheTime = Date.now()
          this.initialized = true
        } else {
          console.error('❌ 文件存储配置加载失败:', response.msg)
          throw new Error(response.msg || '加载文件存储配置失败')
        }
      } catch (error) {
        console.error('❌ 文件存储配置加载异常:', error)
        throw error
      } finally {
        this.loading = false
      }
    },

    /**
     * 获取指定ID的存储配置（智能缓存）
     * @param {number} configId - 配置ID
     * @returns {Promise<Object|null>} 存储配置
     */
    async getConfigById(configId) {
      if (!configId) return null

      // 自动获取配置列表（包括已停用的）
      const configs = await this.getConfigs({ enabledOnly: false })
      const config = configs.find(config => config.configId === configId) || null
      if (config) {
        console.log(`✅ 找到存储配置: ${config.configName}`)
      } else {
        console.log(`⚠️ 未找到ID为 ${configId} 的存储配置`)
      }
      return config
    },

    /**
     * 获取默认存储配置（智能缓存）
     * @returns {Promise<Object|null>} 默认存储配置
     */
    async getDefaultConfig() {
      // 自动获取启用的配置列表
      await this.getConfigs({ enabledOnly: true })
      return this.defaultConfig
    },

    /**
     * 刷新缓存
     * 在存储配置发生变更时调用
     */
    async refreshCache() {
      this.clearCache()
      await this.loadConfigs()
    },

    /**
     * 清空缓存
     */
    clearCache() {
      console.log('🗑️ 清空文件存储配置缓存')
      this.configs = []
      this.cacheTime = null
      this.initialized = false
    },
  }
})

export default useFileConfigStore

/**
 * 便捷函数：获取文件存储配置列表
 * @param {Object} options - 选项
 * @returns {Promise<Array>} 存储配置列表
 */
export async function getFileConfigs(options = {}) {
  const store = useFileConfigStore()
  return await store.getConfigs(options)
}

/**
 * 便捷函数：获取默认文件存储配置
 * @returns {Promise<Object|null>} 默认存储配置
 */
export async function getDefaultFileConfig() {
  const store = useFileConfigStore()
  return await store.getDefaultConfig()
}

/**
 * 便捷函数：根据ID获取文件存储配置
 * @param {number} configId - 配置ID
 * @returns {Promise<Object|null>} 存储配置
 */
export async function getFileConfigById(configId) {
  const store = useFileConfigStore()
  return await store.getConfigById(configId)
}

/**
 * 便捷函数：刷新文件存储配置缓存
 */
export async function refreshFileConfigCache() {
  const store = useFileConfigStore()
  return await store.refreshCache()
}

/**
 * 便捷函数：获取默认配置ID或第一个可用配置ID
 * @param {Array} configs - 配置列表（可选，如果不传会自动获取）
 * @returns {Promise<number|null>} 配置ID
 */
export async function getDefaultConfigId(configs = null) {
  if (!configs) {
    const store = useFileConfigStore()
    configs = await store.getConfigs({ enabledOnly: true })
  }
  
  if (!configs || configs.length === 0) {
    console.warn('⚠️ 没有可用的存储配置')
    return null
  }
  
  // 优先使用默认配置
  const defaultConfig = configs.find(config => config.isDefault === 1)
  if (defaultConfig) {
    return defaultConfig.configId
  }
  
  // 如果没有默认配置，使用第一个可用配置
  const firstConfig = configs[0]
  return firstConfig.configId
}
